// type shap = {
//   xpos?: number;
//   ypos?: number;
//   width?: number;
//   height?: number;
// };

// import { ChildProcess } from "node:child_process"

// /**
//  * 绘制形状
//  * @param this CanvasRenderingContext2D
//  * @param param1 shap 形状参数
//  * @param param2 options 绘制选项
//  * @returns void
//  */
// // eslint-disable-next-line @typescript-eslint/no-unused-vars
// function _paintShap(
//   this: CanvasRenderingContext2D,
//   { xpos = 0, ypos = 0, width = 0, height = 0 }: shap,
//   options?: {
//     fillStyle?: string;
//     strokeStyle?: string;
//     lineWidth?: number;
//     miterLimit?: number;
//     globalAlpha?: number;
//     globalCompositeOperation?: GlobalCompositeOperation;
//     shadowOffsetX?: number;
//     shadowOffsetY?: number;
//     shadowBlur?: number;
//     shadowColor?: string;
//     fillColor?: string;
//     strokeColor?: string;
//   },
// ) {
//   if (options) {
//     this.fillStyle = options.fillStyle as string;
//     this.strokeStyle = options.strokeStyle as string;
//     this.lineWidth = options.lineWidth as number;
//     this.miterLimit = options.miterLimit as number;
//     this.globalAlpha = options.globalAlpha as number;
//     this.globalCompositeOperation =
//       options.globalCompositeOperation as GlobalCompositeOperation;
//     this.shadowOffsetX = options.shadowOffsetX as number;
//     this.shadowOffsetY = options.shadowOffsetY as number;
//     this.shadowBlur = options.shadowBlur as number;
//     this.shadowColor = options.shadowColor as string;
//   }
//   this.fillRect(xpos, ypos, width, height);
// }

// function test1(arg1?: string, arg2?: string, ...args: unknown[]) {
//   args[1] = '你好'
//   console.log('arg1 is', args[0]);
//   console.log('and arguments is', args);
//   // arguments = {0:'zege'}
// }
// test1('这个')

// 实现尾调优化的递归示例

/**
 * 区域接口
 */
/* interface TreePoint {
  name: string
  code: number | string
  children?: TreePoint[]
}


const samData: TreePoint[] = [
  {
    name: '中国',
    code: 'CN',
    children: [
      {
        name: '广东省',
        code: 'GD',
        children: [
          {
            name: '广州市',
            code: '4401',
            children: [
              {
                name: '天河区',
                code: '123',
              },
              {
                name: '龙华区',
                code: '124',
              },
              {
                name: '福田区',
                code: '125',
              }
            ]
          },
          {
            name: '深圳市',
            code: '4403',
          },
        ],
      },
      {
        name: '北京市',
        code: 'BJ',
      },
    ],
  },
]

function flatTree(points: TreePoint[]): Map<string | number, TreePoint> {
  const result = new Map<string | number, TreePoint>()

  function flatPoint(map: typeof result, data: typeof points) {
    const children: typeof data = []
    for (const point of data) {
      map.set(point.code, point)
      const _children = point.children
      if (_children) {
        children.push(..._children)
      }
    }
    if (children.length == 0) return map
    return flatPoint(map, children)
  }

  function flatPoint2(map: typeof result, data: typeof points) {
    for (const point of data) {
      map.set(point.code, point)
    }

    const children: typeof data = []
    for (const point of data) {
      if (point.children) children.push(...point.children)
    }

    if (children.length === 0) return map
    return flatPoint(map, children)
  }

  return flatPoint(result, points)
}

const map = flatTree(samData)

console.log('map is', map); */

// function double(
//   value: undefined,
//   context: ClassFieldDecoratorContext
// ) {
//   // 返回一个函数，该函数接收字段定义的初始值，返回实际的初始值
//   return function(initialValue: number) {
//     console.log(`初始化字段 ${String(context.name)}，原始值: ${initialValue}`);
//     return initialValue * 2;
//   };
// }

// class Item {
//   @double
//   price: number = 100;
// }

// const item = new Item();
// console.log(item.price); // 200

// function logged<This, Args extends unknown[], R>(
//   value: (this: This, ...args: Args) => R,
//   context: ClassMethodDecoratorContext<This, typeof value>
// ): typeof value {
//   const methodName = String(context.name);

//   function wrappedMethod(this: This, ...args: Args): R {
//     console.log(`[LOG] 调用方法 ${methodName}，参数:`, args);
//     const result = value.apply(this, args);
//     console.log(`[LOG] 方法 ${methodName} 完成，返回:`, result);
//     return result;
//   }

//   return wrappedMethod;
// }

// class Calculator {
//   @logged
//   add(a: number, b: number): number {
//     return a + b;
//   }

//   @logged
//   multiply(a: number, b: number): number {
//     return a * b;
//   }
// }

// const calc = new Calculator();
// calc.add(2, 3);
// calc.multiply(4, 5);

// type AutoAccessorDescriptor<This, V> = {
//   get?: (this: This) => V;
//   set?: (this: This, value: V) => void;
// };

// function validated<This = unknown, V = unknown>(
//   value: AutoAccessorDescriptor<This, V>,
//   context: ClassAutoAccessorDecoratorContext
// ): AutoAccessorDescriptor<This, V> | void {
//   const { name } = context;

//   // 保存原始 getter/setter（可能为 undefined）
//   const originalGet = value.get;
//   const originalSet = value.set;

//   // 创建验证逻辑，严格标注 this 与 newValue 类型
//   function validateAndSet(this: This, newValue: V): void {
//     const propName = String(name);

//     if (propName === 'age') {
//       if (typeof newValue !== 'number' || (newValue as unknown as number) < 0) {
//         throw new Error('年龄必须是非负数');
//       }
//     }

//     if (propName === 'name') {
//       if (typeof newValue !== 'string' || String(newValue).trim() === '') {
//         throw new Error('名称不能是空字符串');
//       }
//     }

//     if (originalSet) {
//       originalSet.call(this, newValue);
//       return;
//     }

//     // 如果没有原始 setter，可尝试通过 context.access（取决于运行时支持）
//     // 这里抛出明确错误以避免隐式 any/未处理分支
//     throw new Error(`属性 ${propName} 不可写`);
//   }

//   return {
//     get: originalGet,
//     set: validateAndSet,
//   };
// }

// class User {
//   @validated
//   accessor name: string;

//   @validated
//   accessor age: number;

//   constructor(name: string, age: number) {
//     this.name = name;
//     this.age = age;
//   }
// }

// const user = new User('Alice', 30);
// console.log(user.name); // Alice
// console.log(user.age); // 30

// try {
//   user.age = -5; // 抛出错误: 年龄必须是非负数
// } catch (e) {
//   console.error(e.message);
// }

// try {
//   user.name = ''; // 抛出错误: 名称不能是空字符串
// } catch (e) {
//   console.error(e.message);
// }

/* function safeLog(label: string){
  return (value: any, context: ClassDecoratorContext | any) => {
    console.log(`[${label}] 装饰器表达式求值: ${context.kind}`);

    context.addInitializer(function(this: any) {
      // 安全地判断是静态还是实例上下文
      const isStaticContext = typeof this === 'function';
      const type = isStaticContext ? "静态" : "实例";

      // 获取类名的安全方式
      const className = isStaticContext 
        ? this.name 
        : this.constructor?.name || 'unknown';

      console.log(`[${label}] ${type}初始化器执行 on ${className}`);

      // 额外调试信息
      console.log(`  - this 类型: ${typeof this}`);
      console.log(`  - context.name: ${String(context.name || 'class')}`);
    });

    return value;
  };
}

// 安全使用
@safeLog("03. 类装饰器")
class SafeMyClass {
  @safeLog("01. 静态字段")
  static staticField = "static value";

  @safeLog("02. 静态方法")
  static staticMethod() {}

  constructor() {
    console.log("[构造函数] 执行");
  }

  @safeLog("04. 实例字段")
  instanceField = "instance value";

  @safeLog("05. 实例方法")
  instanceMethod() {}
}

// 创建实例
console.log("\n--- 创建实例 ---");
const instance = new SafeMyClass();
console.log("\n--- 创建实例2 ---");
const instance2 = new SafeMyClass(); */

// function logMethod<This, Arg extends unknown[], R>(
//   options: { prefix?: string; level?: 'debug' | 'info' | 'warn' | 'error' } = {}
// ) {
//   const { prefix = '[LOG]', level = 'info' } = options;
//   type ThisProto = {
//     _logMethods: Set<unknown>
//     constructor: {
//       // [key: string]: unknown
//       _logMethods: Set<unknown>
//       new(...args: unknown[]): This;
//     },
//   }

//   return (
//     value: (this: This, ...args: Arg) => R,
//     context: ClassMethodDecoratorContext
//   ): typeof value | void => {
//     const methodName = String(context.name);
//     const isStatic = context.static;

//     context.addInitializer(function (this: ThisProto): void {
//       const target = isStatic ? this : this.constructor;
//       // const target = isStatic ? this : this.constructor;
//       if (!target._logMethods) {
//         target._logMethods = new Set();
//       }
//       target._logMethods.add(methodName);
//     } as (this: unknown) => void);

//     return function (this: ThisProto | This, ...args: Arg) {
//       const logger = console[level];
//       const instanceTag = isStatic ? 'static' : `instance(${(this as ThisProto).constructor?.name})`;

//       logger(
//         `${prefix} 调用 ${instanceTag}.${methodName}`,
//         '参数:', args
//       );

//       const result = value.apply(this as This, args);

//       logger(
//         `${prefix} 完成 ${instanceTag}.${methodName}`,
//         '返回值:', result
//       );

//       return result;
//     };
//   };
// }

// class DatabaseService {
//   @logMethod({ prefix: '[DB]', level: 'debug' })
//   static connect(connectionString: string): boolean {
//     console.log(`连接到 ${connectionString}`);
//     return true;
//   }

//   @logMethod({ prefix: '[DB]' })
//   query(sql: string): unknown[] {
//     console.log(`执行查询: ${sql}`);
//     return [{ id: 1, name: '测试' }];
//   }
// }

// // 使用
// DatabaseService.connect('localhost:5432');
// const db = new DatabaseService();
// db.query('SELECT * FROM users');

// const o = {}
// Object.defineProperty(o, 'bar', 'bar')
// console.log(`o bar is`,o.bar);
